﻿//说明:
//rc: RedisClient(Redis客户端)
//注意:
//redis默认编码为utf-8,推荐web代码统一使用U码

函数 Redis测试()
	//声明类前需要初始化redis,构建类时自动从连接池抽取连接
	WoRedis类 rc
	//设置一个testa键值为abc
	rc.置值(U"testU", U"abc")
	调试输出A(A"值",rc.取值(U"testU"))
	//默认过期时间-1也就是不过期
	调试输出A(A"剩余过期时间",rc.取键剩余过期时间(U"testU"))
	//设置5秒过期
	rc.置键过期时间(U"testU", 5)
	延迟(1000 * 2)
	//延迟2S后如果忽略延迟,剩下3S
	调试输出A(A"剩余过期时间",rc.取键剩余过期时间(U"testU"))
	rc.删除键(U"testU")
	//直接执行置值指令
	rc.执行命令(U"set", U"exd", U"123")
	//直接执行获取指令 
	动态数组<文本型A>结果数组
	如果 rc.执行命令(结果数组, U"get", U"exd")
		调试输出A(A"get->exd",结果数组[0])
	rc.置值(U"exd1",1)
	rc.置值(U"exd2",2)
	调试输出A(A"随机键", rc.取随机键())
	rc.删除键(U"exd")
	rc.删除键(U"exd1")
	rc.删除键(U"exd2")
	调试输出("-----------------------------")
	调试输出("-----------------------------")
	//Redis有默认0-15个数据库,连接之后数据库索引默认0
	//切换数据库
	rc.切换数据库(2)
	rc.置值(U"dbtest", U"123")
	//将数据库切换为3
	rc.切换数据库(3)
	//此时无法取到值
	调试输出A(A"数据库值",rc.取值(U"dbtest"))
	//切回数据库
	rc.切换数据库(2)
	//正常取值
	调试输出A(A"数据库值", rc.取值(U"dbtest"))
	rc.切换数据库(2)
	调试输出("-----------------------------")
	调试输出("-----------------------------")
	rc.删除键(U"dbtest")
	rc.切换数据库(0)

函数 Redis测试_运算()
	调试输出("------------运算-----------------")
	整型 结果
	WoRedis类 rc
	rc.置值(U"testm", 9)
	rc.键自增(U"testm",&结果)
	调试输出A(结果)
	rc.键自减(U"testm",&结果)
	调试输出A(结果)
	rc.键增加(U"testm",6,&结果)
	调试输出A(结果)
	rc.删除键(U"testm")

函数 Redis测试_哈希表()
	调试输出("------------哈希表-----------------")
	字典<文本型A, 文本型A> map
	map[U"U"] = U"1"
	map[U"b"] = U"2"
	map[U"c"] = U"3"
	WoRedis类 rc
	rc.哈希表_置值(U"testmap", map)
	调试输出A(rc.哈希表_字段是否存在(U"testmap", U"U"),rc.哈希表_字段是否存在(U"testmap", U"d"))
	rc.哈希表_置值Ex(U"testmap", U"d", 4)
	调试输出A(rc.哈希表_字段是否存在(U"testmap", U"U"), rc.哈希表_字段是否存在(U"testmap", U"d"))
	调试输出A(A"a -> ",rc.哈希表_取字段值(U"testmap",U"U"))
	rc.哈希表_取所有字段(U"testmap", map)
	变量循环 迭代器 iter = map.第一个();iter != map.空值();iter++
		调试输出A(iter.键, U" -> ", iter.值)
	调试输出A(A"--------")
	整型 值=0
	rc.哈希表_值增加(U"testmap", U"d", 233, &值)
	调试输出A(值)
	调试输出A(A"--------")
	动态数组<文本型A> 字段列表
	rc.哈希表_取所有字段名(U"testmap", 字段列表)
	变量循环 整型 i=0; i<字段列表.取成员数(); i++
		调试输出A(字段列表[i])
	调试输出A(A"--------")
	rc.哈希表_取所有字段值(U"testmap", 字段列表)
	变量循环 整型 i=0; i<字段列表.取成员数(); i++
		调试输出A(字段列表[i])
	调试输出A(A"--------")
	rc.哈希表_取字段值批量(字段列表,U"testmap", U"U", U"c", U"d")
	变量循环 整型 i=0; i<字段列表.取成员数(); i++
		调试输出A(字段列表[i])
	rc.删除键(U"testmap")

//redis的列表可以看做一个栈结构,遵循先入后出,与传统栈不同的是redis的列表灵活性更高
//例如命令中以l开头的命令是遵循先入后出,而r开头则是相反
函数 Redis测试_列表()
	调试输出("------------列表-----------------")
	动态数组<文本型A> 数据列表
	WoRedis类 rc
	rc.列表_压入数据(U"testlist", 1, 2, 3,4, U"U")
	调试输出A(rc.列表_弹出数据(U"testlist"))
	rc.列表_取范围数据(数据列表, U"testlist", 0, 1)
	变量循环 整型 i=0; i<数据列表.取成员数(); i++
		调试输出A(数据列表[i])
	rc.列表_移除数据(U"testlist", 0, 2)
	rc.列表_置数据(U"testlist", 0, 233)
	rc.列表_压入数据(U"testlist", 66, 77, 88, U"U")
	调试输出A(A"--------")
	rc.列表_取范围数据(数据列表, U"testlist")
	变量循环 整型 i=0; i<数据列表.取成员数(); i++
		调试输出A(数据列表[i])
	调试输出A(A"--------")
	rc.列表_裁剪(U"testlist", 1, 2)
	rc.列表_取范围数据(数据列表, U"testlist")
	变量循环 整型 i=0; i<数据列表.取成员数(); i++
		调试输出A(数据列表[i])
	rc.删除键(U"testlist")

//Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
函数 Redis测试_集合()
	调试输出("------------集合-----------------")
	WoRedis类 rc
	rc.集合_加入数据(U"testset", U"111", U"111", U"222", U"333")
	rc.集合_加入数据(U"testset1", U"111", U"444", U"555", U"666")
	整型 返回值
	rc.集合_取成员数(U"testset",&返回值)
	调试输出A(返回值)
	动态数组<文本型A> 数据列表
	调试输出A(rc.集合_成员是否存在(U"testset",U"111"),rc.集合_成员是否存在(U"testset",U"aaU"))
	调试输出A(A"--------")
	rc.集合_取差集(数据列表, U"testset", U"testset1")
	变量循环 整型 i=0; i<数据列表.取成员数(); i++
		调试输出A(数据列表[i])
	调试输出A(A"--------")
	rc.集合_取交集(数据列表, U"testset", U"testset1")
	变量循环 整型 i=0; i<数据列表.取成员数(); i++
		调试输出A(数据列表[i])
	调试输出A(A"--------")
	rc.集合_移动成员(U"testset",U"testset1",U"333")
	rc.集合_取所有成员(U"testset1",数据列表)
	变量循环 整型 i=0; i<数据列表.取成员数(); i++
		调试输出A(数据列表[i])
	调试输出A(A"随机弹出成员", rc.集合_随机弹出成员(U"testset1"))
	调试输出A(A"--------")
	rc.集合_取随机成员(数据列表,U"testset1",2)
	变量循环 整型 i=0; i<数据列表.取成员数(); i++
		调试输出A(数据列表[i])
	rc.集合_移除成员(U"testset1", U"333")
	调试输出A(A"--------")
	rc.集合_取并集(数据列表,U"testset",U"testset1")
	变量循环 整型 i=0; i<数据列表.取成员数(); i++
		调试输出A(数据列表[i])
	rc.删除键(U"testset")
	rc.删除键(U"testset1")

//有序集合(zset)和无序集合一样都是string类型元素的集合，且不允许重复的成员。
//不同的是每个元素都会关联一个 double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序。
//有序集合的成员是唯一的,但分数(score)却可以重复。
函数 Redis测试_有序集合()
	调试输出("------------有序集合-----------------")
	WoRedis类 rc
	字典<文本型A,双浮点型> 集合数据
	集合数据[U"百度"] = 100
	集合数据[U"淘宝"] = 900
	集合数据[U"炫彩"] = 1000
	集合数据[U"微信"] = 800
	集合数据[U"迅雷"] = 700
	双浮点型 分数
	rc.有序集合_取成员分数(U"testzset",U"炫彩",&分数)
	调试输出A(分数)
	整型 返回数值
	rc.有序集合_添加成员(U"testzset", 集合数据)
	rc.有序集合_取成员数(U"testzset",&返回数值)
	调试输出A(A"成员数", 返回数值)
	rc.有序集合_取区间分数成员数(U"testzset",700,800,&返回数值)
	调试输出A(A"700 - 800 成员数", 返回数值)
	rc.有序集合_取区间成员(U"testzset", 0, -1, 集合数据)
	调试输出A(A"--------")
	变量循环 迭代器 iter = 集合数据.第一个();iter != 集合数据.空值();iter++
		调试输出A(编码_Utf8转Gbk(iter.键), iter.值)
	调试输出A(A"----700 - 800 成员----")
	rc.有序集合_取分数区间成员(U"testzset", 800, 700, 集合数据)
	变量循环 迭代器 iter = 集合数据.第一个();iter != 集合数据.空值();iter++
		调试输出A(编码_Utf8转Gbk(iter.键), iter.值)


函数 整型 入口函数()

	//先初始化Redis连接池
	Wo数据库_Redis初始化(U"192.168.1.210",6379,U"Hy.20010629")
	Redis测试()
	Redis测试_运算()
	Redis测试_哈希表()
	Redis测试_列表()
	Redis测试_集合()
	Redis测试_有序集合()
	返回 0
